// PositionController.java
package com.zyp.jobseeker.controller;

import com.zyp.jobseeker.entity.Position;
import com.zyp.jobseeker.enums.PositionStatus;
import com.zyp.jobseeker.enums.UserRole;
import com.zyp.jobseeker.service.PositionService;
import com.zyp.jobseeker.utils.ResultUtil;
import com.github.pagehelper.PageInfo;
import com.zyp.jobseeker.utils.JwtUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * 岗位控制器
 * 处理岗位相关的CRUD请求
 */
@RestController
@RequestMapping("/api/position")
public class PositionController {
    // 添加日志记录器
    private static final Logger logger = LoggerFactory.getLogger(PositionController.class);

    @Autowired
    private PositionService positionService;

    @Autowired
    private JwtUtil jwtUtil;

    /**
     * 发布新岗位
     * 企业用户发布新的招聘岗位
     */
    @PostMapping("/publish")
    @PreAuthorize("hasAuthority('ENTERPRISE')")  // 使用PreAuthorize验证角色
    public ResultUtil<Long> publishPosition(
            @RequestHeader("Authorization") String token,  // 直接获取token
            @RequestBody Map<String, Object> positionInfo) {
        try {
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);

            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            // 添加日志记录
            logger.info("开始发布新岗位，请求数据: {}", positionInfo);

            // 从token中获取企业ID（使用getUserIdFromToken）
            Long enterpriseId = jwtUtil.getUserIdFromToken(token);
            logger.debug("解析到企业ID: {}", enterpriseId);

            // 调用服务层发布岗位
            Long positionId = positionService.publishPosition(enterpriseId, positionInfo);

            logger.info("岗位发布成功，生成岗位ID: {}", positionId);
            return ResultUtil.success(positionId);
        } catch (Exception e) {
            // 记录异常日志
            logger.error("岗位发布失败: ", e);
            return ResultUtil.fail("岗位发布失败: " + e.getMessage());
        }
    }

    /**
     * 获取岗位详情
     * 学生和管理员都可以查看完整信息
     */
    @GetMapping("/{id}")
    public ResultUtil<Position> getPositionById(
            @RequestHeader("Authorization") String token,  // 直接获取token
            @PathVariable Long id) {
        try {
            // 添加日志记录
            logger.info("开始获取岗位详情，岗位ID: {}", id);
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);

            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            // 从token中获取用户角色（使用getUsernameFromToken）
            String userRole = UserRole.getByCode(jwtUtil.getRoleFromToken(token)).getDesc();
            logger.debug("请求用户角色: {}", userRole);

            // 调用服务层获取岗位信息（不再区分角色）
            Position position = positionService.getPositionById(id);

            logger.info("成功获取岗位信息，岗位名称: {}", position.getPositionName());
            return ResultUtil.success(position);
        } catch (Exception e) {
            // 记录异常日志
            logger.error("获取岗位详情失败，岗位ID: {}", id, e);
            return ResultUtil.fail(404, "岗位信息不存在");
        }
    }

    /**
     * 更新岗位信息
     */
    @PutMapping("/{id}")
    @PreAuthorize("hasAuthority('ENTERPRISE')")  // 使用PreAuthorize验证角色
    public ResultUtil<String> updatePosition(
            @RequestHeader("Authorization") String token,  // 直接获取token
            @PathVariable Long id,
            @RequestBody Map<String, Object> updateData) {
        try {
            // 添加日志记录
            logger.info("开始更新岗位信息，岗位ID: {}", id);
            logger.debug("更新数据: {}", updateData);
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);

            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            // 从token中获取企业ID（使用getUserIdFromToken）
            Long enterpriseId = jwtUtil.getUserIdFromToken(token);
            logger.debug("解析到企业ID: {}", enterpriseId);

            // 调用服务层更新岗位
            boolean success = positionService.updatePosition(id, updateData, enterpriseId);

            if (success) {
                logger.info("岗位更新成功，岗位ID: {}", id);
                return ResultUtil.success("岗位信息更新成功");
            } else {
                logger.warn("岗位更新失败，岗位ID: {}, 原因: 没有权限或岗位不存在", id);
                return ResultUtil.fail(403, "岗位更新失败：没有权限或岗位不存在");
            }
        } catch (Exception e) {
            // 记录异常日志
            logger.error("岗位更新失败，岗位ID: {}", id, e);
            return ResultUtil.fail(500, "岗位更新失败: " + e.getMessage());
        }
    }

    /**
     * 废除岗位
     */
    @DeleteMapping("/{id}")
    @PreAuthorize("hasAuthority('ENTERPRISE')")  // 使用PreAuthorize验证角色
    public ResultUtil<String> deprecatePosition(
            @RequestHeader("Authorization") String token,  // 直接获取token
            @PathVariable Long id) {
        try {
            // 添加日志记录
            logger.info("开始废除岗位，岗位ID: {}", id);
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);

            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            // 从token中获取企业ID（使用getUserIdFromToken）
            Long enterpriseId = jwtUtil.getUserIdFromToken(token);
            logger.debug("解析到企业ID: {}", enterpriseId);

            // 调用服务层废除岗位
            boolean success = positionService.deprecatePosition(id, enterpriseId);

            if (success) {
                logger.info("岗位废除成功，岗位ID: {}", id);
                return ResultUtil.success("岗位已成功废除");
            } else {
                logger.warn("岗位废除失败，岗位ID: {}, 原因: 没有权限或岗位不存在", id);
                return ResultUtil.fail(403, "岗位废除失败：没有权限或岗位不存在");
            }
        } catch (Exception e) {
            // 记录异常日志
            logger.error("岗位废除失败，岗位ID: {}", id, e);
            return ResultUtil.fail(500, "岗位废除失败: " + e.getMessage());
        }
    }

    /**
     * 企业岗位列表查询
     */
    @GetMapping("/enterprise")
    @PreAuthorize("hasAuthority('ENTERPRISE')")  // 使用PreAuthorize验证角色
    public ResultUtil<PageInfo<Position>> getEnterprisePositions(
            @RequestHeader("Authorization") String token,  // 直接获取token
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize) {
        try {
            // 添加日志记录
            logger.debug("分页参数: pageNum={}, pageSize={}", pageNum, pageSize);
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);

            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            // 从token中获取企业ID（使用getUserIdFromToken）
            Long enterpriseId = jwtUtil.getUserIdFromToken(token);
            logger.debug("解析到当前企业ID: {}", enterpriseId);

//            // 验证企业ID是否匹配（防止越权访问）
//            if (!enterpriseId.equals(currentEnterpriseId)) {
//                logger.warn("企业岗位查询被拒绝，请求企业ID: {} 与当前企业ID: {} 不匹配", enterpriseId, currentEnterpriseId);
//                return ResultUtil.fail(403, "没有权限查看其他企业的岗位");
//            }

            // 调用服务层获取企业岗位列表
            PageInfo<Position> pageInfo = positionService.getEnterprisePositions(enterpriseId, pageNum, pageSize);

            logger.info("企业岗位查询成功，总记录数: {}", pageInfo.getTotal());
            return ResultUtil.success(pageInfo);
        } catch (Exception e) {
            // 记录异常日志
            logger.error("企业岗位查询失败，失败信息：", e);
            return ResultUtil.fail(500, "企业岗位查询失败: " + e.getMessage());
        }
    }

    /**
     * 岗位搜索接口
     */
    @GetMapping("/search")
    @PreAuthorize("hasAuthority('STUDENT') or hasAuthority('ADMIN')")  // 使用PreAuthorize验证角色
    public ResultUtil<PageInfo<Position>> searchPositions(
            @RequestHeader("Authorization") String token,  // 直接获取token
            @RequestParam(required = false) String keyword,
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize) {
        try {
            // 添加日志记录
            logger.info("开始搜索岗位，关键字: {}", keyword == null ? "无" : keyword);
            logger.debug("分页参数: pageNum={}, pageSize={}", pageNum, pageSize);
            // 从请求头中获取token
            if (token == null || !token.startsWith("Bearer ")) {
                return ResultUtil.fail(401, "未提供有效的认证信息");
            }
            token = token.substring(7);

            // 验证token是否过期
            if (jwtUtil.isTokenExpired(token)) {
                return ResultUtil.fail(401, "认证信息已过期，请重新登录");
            }
            // 调用服务层搜索岗位（不再区分角色）
            PageInfo<Position> pageInfo = positionService.searchPositions(keyword, pageNum, pageSize);

            logger.info("岗位搜索成功，返回记录数: {}", pageInfo.getList().size());
            return ResultUtil.success(pageInfo);
        } catch (Exception e) {
            // 记录异常日志
            logger.error("岗位搜索失败，关键字: {}", keyword == null ? "无" : keyword, e);
            return ResultUtil.fail(500, "岗位搜索失败: " + e.getMessage());
        }
    }
}
